package com.javaxiaobear.module.system.mapper;

import static com.javaxiaobear.module.system.domain.table.SysDeptTableDef.SYS_DEPT;
import static com.javaxiaobear.module.system.domain.table.SysRoleTableDef.SYS_ROLE;
import static com.javaxiaobear.module.system.domain.table.SysUserRoleTableDef.SYS_USER_ROLE;
import static com.javaxiaobear.module.system.domain.table.SysUserTableDef.SYS_USER;

import cn.hutool.core.collection.ListUtil;
import com.javaxiaobear.module.system.domain.SysRole;
import com.mybatisflex.core.BaseMapper;
import com.mybatisflex.core.paginate.Page;
import com.mybatisflex.core.query.QueryChain;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * 角色表 数据层
 *
 * @author javaxiaobear
 */
public interface SysRoleMapper extends BaseMapper<SysRole> {

  /** 根据条件分页查询角色数据 */
  default Object selectRoleList(SysRole role, Page<SysRole> page) {
    var query =
        QueryChain.of(this)
            .select(
                SYS_ROLE.ROLE_ID,
                SYS_ROLE.ROLE_NAME,
                SYS_ROLE.ROLE_KEY,
                SYS_ROLE.ROLE_SORT,
                SYS_ROLE.DATA_SCOPE,
                SYS_ROLE.MENU_CHECK_STRICTLY,
                SYS_ROLE.DEPT_CHECK_STRICTLY,
                SYS_ROLE.STATUS,
                SYS_ROLE.DEL_FLAG,
                SYS_ROLE.CREATE_TIME,
                SYS_ROLE.REMARK)
            .from(SYS_ROLE)
            .leftJoin(SYS_USER_ROLE)
            .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
            .leftJoin(SYS_USER)
            .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
            .leftJoin(SYS_DEPT)
            .on(SYS_USER.DEPT_ID.eq(SYS_DEPT.DEPT_ID))
            .where(SYS_ROLE.DEL_FLAG.eq("0"))
            .and(
                SYS_ROLE
                    .ROLE_ID
                    .eq(role.getRoleId())
                    .when(role.getRoleId() != null && role.getRoleId() != 0))
            .and(
                SYS_ROLE
                    .ROLE_NAME
                    .like(role.getRoleName())
                    .when(role.getRoleName() != null && !role.getRoleName().isEmpty()))
            .and(
                SYS_ROLE
                    .STATUS
                    .eq(role.getStatus())
                    .when(role.getStatus() != null && !role.getStatus().isEmpty()))
            .and(
                SYS_ROLE
                    .ROLE_KEY
                    .like(role.getRoleKey())
                    .when(role.getRoleKey() != null && !role.getRoleKey().isEmpty()))
            .orderBy(SYS_ROLE.ROLE_SORT.asc());

    // 处理日期范围检索
    if (role.getParams() != null) {
      String beginTime = (String) role.getParams().get("beginTime");
      String endTime = (String) role.getParams().get("endTime");

      if (beginTime != null && !beginTime.isEmpty()) {
        query.and(SYS_ROLE.CREATE_TIME.ge(parseDate(beginTime)));
      }

      if (endTime != null && !endTime.isEmpty()) {
        query.and(SYS_ROLE.CREATE_TIME.le(parseDate(endTime)));
      }

      // 数据范围过滤 - 注意：这里简化处理，实际应用中需要根据具体的dataScope实现
      String dataScope = (String) role.getParams().get("dataScope");
      // 如果dataScope不为空，可以在这里添加相应的条件
    }
    if (page == null) {
      return query.list();
    } else {
      return query.page(page);
    }
  }

  /** 根据用户ID查询角色 */
  default List<SysRole> selectRolePermissionByUserId(Long userId) {
    return QueryChain.of(this)
        .select(
            SYS_ROLE.ROLE_ID,
            SYS_ROLE.ROLE_NAME,
            SYS_ROLE.ROLE_KEY,
            SYS_ROLE.ROLE_SORT,
            SYS_ROLE.DATA_SCOPE,
            SYS_ROLE.MENU_CHECK_STRICTLY,
            SYS_ROLE.DEPT_CHECK_STRICTLY,
            SYS_ROLE.STATUS,
            SYS_ROLE.DEL_FLAG,
            SYS_ROLE.CREATE_TIME,
            SYS_ROLE.REMARK)
        .from(SYS_ROLE)
        .leftJoin(SYS_USER_ROLE)
        .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
        .leftJoin(SYS_USER)
        .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
        .leftJoin(SYS_DEPT)
        .on(SYS_USER.DEPT_ID.eq(SYS_DEPT.DEPT_ID))
        .where(SYS_ROLE.DEL_FLAG.eq("0"))
        .and(SYS_USER_ROLE.USER_ID.eq(userId))
        .list();
  }

  /** 查询所有角色 */
  default List<SysRole> selectRoleAll() {
    return QueryChain.of(this)
        .select(
            SYS_ROLE.ROLE_ID,
            SYS_ROLE.ROLE_NAME,
            SYS_ROLE.ROLE_KEY,
            SYS_ROLE.ROLE_SORT,
            SYS_ROLE.DATA_SCOPE,
            SYS_ROLE.MENU_CHECK_STRICTLY,
            SYS_ROLE.DEPT_CHECK_STRICTLY,
            SYS_ROLE.STATUS,
            SYS_ROLE.DEL_FLAG,
            SYS_ROLE.CREATE_TIME,
            SYS_ROLE.REMARK)
        .from(SYS_ROLE)
        .leftJoin(SYS_USER_ROLE)
        .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
        .leftJoin(SYS_USER)
        .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
        .leftJoin(SYS_DEPT)
        .on(SYS_USER.DEPT_ID.eq(SYS_DEPT.DEPT_ID))
        .list();
  }

  /** 根据用户ID获取角色选择框列表 */
  default List<Long> selectRoleListByUserId(Long userId) {
    return QueryChain.of(this)
        .select(SYS_ROLE.ROLE_ID)
        .from(SYS_ROLE)
        .leftJoin(SYS_USER_ROLE)
        .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
        .leftJoin(SYS_USER)
        .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
        .where(SYS_USER.USER_ID.eq(userId))
        .listAs(Long.class);
  }

  /** 通过角色ID查询角色 */
  default SysRole selectRoleById(Long roleId) {
    return QueryChain.of(this)
        .select(
            SYS_ROLE.ROLE_ID,
            SYS_ROLE.ROLE_NAME,
            SYS_ROLE.ROLE_KEY,
            SYS_ROLE.ROLE_SORT,
            SYS_ROLE.DATA_SCOPE,
            SYS_ROLE.MENU_CHECK_STRICTLY,
            SYS_ROLE.DEPT_CHECK_STRICTLY,
            SYS_ROLE.STATUS,
            SYS_ROLE.DEL_FLAG,
            SYS_ROLE.CREATE_TIME,
            SYS_ROLE.REMARK)
        .from(SYS_ROLE)
        .leftJoin(SYS_USER_ROLE)
        .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
        .leftJoin(SYS_USER)
        .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
        .leftJoin(SYS_DEPT)
        .on(SYS_USER.DEPT_ID.eq(SYS_DEPT.DEPT_ID))
        .where(SYS_ROLE.ROLE_ID.eq(roleId))
        .one();
  }

  /** 根据用户ID查询角色 */
  default List<SysRole> selectRolesByUserName(String userName) {
    return QueryChain.of(this)
        .select(
            SYS_ROLE.ROLE_ID,
            SYS_ROLE.ROLE_NAME,
            SYS_ROLE.ROLE_KEY,
            SYS_ROLE.ROLE_SORT,
            SYS_ROLE.DATA_SCOPE,
            SYS_ROLE.MENU_CHECK_STRICTLY,
            SYS_ROLE.DEPT_CHECK_STRICTLY,
            SYS_ROLE.STATUS,
            SYS_ROLE.DEL_FLAG,
            SYS_ROLE.CREATE_TIME,
            SYS_ROLE.REMARK)
        .from(SYS_ROLE)
        .leftJoin(SYS_USER_ROLE)
        .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
        .leftJoin(SYS_USER)
        .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
        .leftJoin(SYS_DEPT)
        .on(SYS_USER.DEPT_ID.eq(SYS_DEPT.DEPT_ID))
        .where(SYS_ROLE.DEL_FLAG.eq("0"))
        .and(SYS_USER.USER_NAME.eq(userName))
        .list();
  }

  /** 校验角色名称是否唯一 */
  default SysRole checkRoleNameUnique(String roleName) {
    return QueryChain.of(this)
        .select(
            SYS_ROLE.ROLE_ID,
            SYS_ROLE.ROLE_NAME,
            SYS_ROLE.ROLE_KEY,
            SYS_ROLE.ROLE_SORT,
            SYS_ROLE.DATA_SCOPE,
            SYS_ROLE.MENU_CHECK_STRICTLY,
            SYS_ROLE.DEPT_CHECK_STRICTLY,
            SYS_ROLE.STATUS,
            SYS_ROLE.DEL_FLAG,
            SYS_ROLE.CREATE_TIME,
            SYS_ROLE.REMARK)
        .from(SYS_ROLE)
        .leftJoin(SYS_USER_ROLE)
        .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
        .leftJoin(SYS_USER)
        .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
        .leftJoin(SYS_DEPT)
        .on(SYS_USER.DEPT_ID.eq(SYS_DEPT.DEPT_ID))
        .where(SYS_ROLE.ROLE_NAME.eq(roleName))
        .and(SYS_ROLE.DEL_FLAG.eq("0"))
        .limit(1)
        .one();
  }

  /** 校验角色权限是否唯一 */
  default SysRole checkRoleKeyUnique(String roleKey) {
    return QueryChain.of(this)
        .select(
            SYS_ROLE.ROLE_ID,
            SYS_ROLE.ROLE_NAME,
            SYS_ROLE.ROLE_KEY,
            SYS_ROLE.ROLE_SORT,
            SYS_ROLE.DATA_SCOPE,
            SYS_ROLE.MENU_CHECK_STRICTLY,
            SYS_ROLE.DEPT_CHECK_STRICTLY,
            SYS_ROLE.STATUS,
            SYS_ROLE.DEL_FLAG,
            SYS_ROLE.CREATE_TIME,
            SYS_ROLE.REMARK)
        .from(SYS_ROLE)
        .leftJoin(SYS_USER_ROLE)
        .on(SYS_USER_ROLE.ROLE_ID.eq(SYS_ROLE.ROLE_ID))
        .leftJoin(SYS_USER)
        .on(SYS_USER.USER_ID.eq(SYS_USER_ROLE.USER_ID))
        .leftJoin(SYS_DEPT)
        .on(SYS_USER.DEPT_ID.eq(SYS_DEPT.DEPT_ID))
        .where(SYS_ROLE.ROLE_KEY.eq(roleKey))
        .and(SYS_ROLE.DEL_FLAG.eq("0"))
        .limit(1)
        .one();
  }

  /** 修改角色信息 */
  default int updateRole(SysRole role) {
    return update(role);
  }

  /** 新增角色信息 */
  default int insertRole(SysRole role) {
    return insert(role);
  }

  /** 通过角色ID删除角色（逻辑删除） */
  default int deleteRoleById(Long roleId) {
    return deleteByCondition(SYS_ROLE.ROLE_ID.eq(roleId));
  }

  /** 批量删除角色信息（逻辑删除） */
  default int deleteRoleByIds(Long[] roleIds) {
    if (roleIds == null || roleIds.length == 0) {
      return 0;
    }
    return deleteBatchByIds(ListUtil.of(roleIds));
  }

  /** 辅助方法：解析日期字符串为Date对象 */
  private Date parseDate(String dateStr) {
    try {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
      return sdf.parse(dateStr);
    } catch (Exception e) {
      return null;
    }
  }
}
